home *** CD-ROM | disk | FTP | other *** search
/ Megarom / Megarom Macintosh CD Software (Quantum Leap)(1992).iso / SOUND / Applications / Sound Input Device ƒ / SID Test Util.c < prev   
C/C++ Source or Header  |  1990-01-05  |  19KB  |  736 lines
  1. /* ************ SID Test Util.c - A test utility for SID *************** */
  2. /*                                                                       */
  3. /*                          Copyright (C) 1990                           */
  4. /*                              The SID Trio                             */
  5. /*                          All Rights Reserved                          */
  6. /*                                                                       */
  7. /*                                                                       */
  8. /* ********************************************************************* */
  9.  
  10.  
  11.  
  12. /****
  13.  *  Note:
  14.  *    This purpose of this program is to 1) assist in the testing of SID
  15.  *    hardware, and to 2) give an example of using the HearHere toolbox.
  16.  *    This application uses a fixed 100K buffer (size set by the constant
  17.  *    BUFFERSIZE) - real applications should always use as much RAM as 
  18.  *    possible for quality recording.
  19.  *
  20.  *  Warning:
  21.  *    Don't set the front and rear windows until you understand what they do.
  22.  *    Setting these windows and turning off "Interrupt on mouse" can lock up
  23.  *    your Mac pretty easily!
  24.  *
  25.  */
  26.  
  27. #include "HearHere.h"
  28. #include <SoundMgr.h>
  29. #include <SoundDvr.h>
  30.  
  31.  
  32.  
  33. /* *** Menu Definitions *** */
  34.  
  35. #define APPLE_MENU        201
  36. #define     ABOUT_ITEM 1
  37.  
  38. #define FILE_MENU        202
  39. #define     QUIT_ITEM 1
  40.  
  41. #define RECORD_MENU        203
  42. #define     DISK_ITEM 1
  43. #define        RAM_ITEM 2
  44.  
  45. #define PLAY_MENU        204
  46.  
  47. #define WINDOWS_MENU    205
  48. #define        FRONT_ITEM 1
  49. #define        REAR_ITEM 2
  50. #define        MOUSEFLAG_ITEM 4
  51.  
  52. #define RATE_MENU        206
  53. #define     R22K_ITEM 1
  54. #define        R11K_ITEM 2
  55. #define     R7K_ITEM 3
  56. #define        R5K_ITEM 4
  57.  
  58.  
  59. /* *** Dialog Definitions *** */
  60.  
  61. #define FRONT_DIALOG 30
  62. #define        ST_ITEM 4
  63. #define        FL_ITEM 6
  64. #define        MW_ITEM 8
  65.  
  66. #define REAR_DIALOG 31
  67. #define        QT_ITEM 4
  68. #define        RL_ITEM 6
  69.  
  70. #define OK        1
  71. #define CANCEL    2
  72.  
  73. #define ABOUT_DIALOG    256
  74. #define OPENING_DIALOG    257
  75. #define RAMREC_DIALOG    258
  76. #define DISKREC_DIALOG    259
  77. #define SID_ALERT        256
  78. #define RECORD_PICT        258
  79.  
  80.  
  81.  
  82. /* *** Other Definitions *** */
  83.  
  84. #define BUFFERSIZE    100000L
  85.  
  86.  
  87.  
  88. /* *** Globals *** */
  89.  
  90. unsigned char *Buffer;        /* address of buffer to use for sound data */
  91. long BufLen;                /* length of Buffer */
  92. long RecordLen;                /* length of recorded data */
  93. Boolean MouseFlag;            /* TRUE if mouse movement stops recording */
  94. Boolean SIDStatus;            /* TRUE if SID is responding and OK */
  95. int SampleRate;                /* sample recording rate */
  96. int FrontStartThresh;        /* front window starting threshold */
  97. int FrontLength;            /* front window length */
  98. int FrontMaxWait;            /* front window max wait */
  99. int RearQuietThresh;        /* rear window quiet threshold */
  100. int RearLength;                /* rear window length */
  101.  
  102.  
  103.  
  104.  
  105.  
  106. main()
  107. {
  108.     int i;
  109.     int code;
  110.     int theMenu,theItem;
  111.     char ch;
  112.     long mResult;
  113.     EventRecord event;
  114.     WindowPtr whichWindow;
  115.     Boolean doneFlag;
  116.     
  117.             /*****
  118.              *  Do Mac initialization things...
  119.              *
  120.              */
  121.     MaxApplZone();
  122.     MoreMasters();
  123.     InitGraf(&thePort);
  124.     InitFonts();
  125.     InitWindows();
  126.     InitMenus();
  127.     TEInit();
  128.     InitDialogs(0L);
  129.     
  130.     FlushEvents(everyEvent,0);
  131.     InitCursor();
  132.     
  133.     MenuInit();                /* create our menus */
  134.     
  135.             /*****
  136.              *  Initial front and rear window parameters
  137.              *
  138.              */
  139.     FrontStartThresh = 0;    /* no front window */
  140.     FrontLength = 0;        /* ... */
  141.     FrontMaxWait = 300;        /* timeout after 300K samples without sound */
  142.     RearQuietThresh = 0;    /* no rear window - end recording by mouse movement */
  143.     RearLength = 0;            /* ... */
  144.     SampleRate = 2;            /* default to 11K sampling rate */
  145.     MouseFlag = TRUE;        /* default to "Interrupt on mouse" checked */
  146.     
  147.     DoOpeningBox();            /* thank you Eric for your suggestions... */
  148.     
  149.             /*****
  150.              *  Set up initial menu checks and disables...
  151.              *
  152.              */
  153.     CheckItem(GetMenu(RATE_MENU),SampleRate,TRUE);
  154.     CheckItem(GetMenu(WINDOWS_MENU),MOUSEFLAG_ITEM,TRUE);
  155.     DisableItem(GetMenu(PLAY_MENU),RAM_ITEM);
  156.     
  157.             /*****
  158.              *  Create the fixed size buffer.  Just give up if there
  159.              *  isn't RAM available for the buffer.
  160.              *
  161.              */
  162.     Buffer = (unsigned char *) NewPtr(BUFFERSIZE);
  163.     if (Buffer == 0L) {
  164.         ParamText("\pCannot allocate RAM","","","");
  165.         Alert(SID_ALERT,0L);
  166.         ExitToShell();
  167.     }
  168.     BufLen = BUFFERSIZE;
  169.     
  170.     doneFlag = FALSE;                /* We've Only Just Begun... */
  171.     
  172.     while (doneFlag == FALSE) {
  173.         
  174.             /*****
  175.              *  Check if SID is alive every time through the event loop.
  176.              *  Note that this isn't really necessary - checking is only
  177.              *  required right before recording.  
  178.              *  
  179.              */
  180.         SIDSetup();
  181.         SIDStatus = (HHError() == 0);
  182.         
  183.             /*****
  184.              *  Standard event handler...
  185.              *
  186.              */
  187.         if (GetNextEvent(everyEvent,&event)) {
  188.         
  189.             code = FindWindow(event.where,&whichWindow);
  190.             switch (event.what) {
  191.             
  192.                 case mouseDown:
  193.                     if (code == inMenuBar) {
  194.                         mResult = MenuSelect(event.where);
  195.                         theMenu = HiWord(mResult);
  196.                         theItem = LoWord(mResult);
  197.                         HandleMenu(&doneFlag,theMenu,theItem);
  198.                     }
  199.                     else if (code == inContent) {
  200.                         if (whichWindow != FrontWindow())
  201.                             SelectWindow(whichWindow);
  202.                     }
  203.                     else if (code == inSysWindow)
  204.                         SystemClick(&event,whichWindow);
  205.                     break;
  206.                     
  207.                 case keyDown:
  208.                 case autoKey:
  209.                     ch = event.message & charCodeMask;
  210.                     if (event.modifiers & cmdKey) {
  211.                         mResult = MenuKey(ch);
  212.                         theMenu = HiWord(mResult);
  213.                         if (theMenu != 0) {
  214.                             theItem = LoWord(mResult);
  215.                             HandleMenu(&doneFlag,theMenu,theItem);
  216.                         }
  217.                     }
  218.                     break;
  219.                     
  220.                 case updateEvt:
  221.                     whichWindow = (WindowPtr) event.message;
  222.                     BeginUpdate(whichWindow);
  223.                     EndUpdate(whichWindow);
  224.                     break;
  225.                 
  226.                 case activateEvt:
  227.                     whichWindow = (WindowPtr) event.message;
  228.                     if (event.modifiers & 0x01 == 1)
  229.                         SelectWindow(whichWindow);
  230.                     break;
  231.                 
  232.             }
  233.         }
  234.     }
  235.     
  236.             /****
  237.              *  Quit was chosen - let HearHere clean up SID,
  238.              *  and exit...
  239.              *
  240.              */
  241.     HHEnd();
  242. }
  243.  
  244.  
  245.  
  246. /*****
  247.  *  MenuInit -- builds the menu bar for the application
  248.  *
  249.  */
  250. MenuInit()
  251. {
  252.     int i;                        /* general integer use */
  253.     Rect bounds;
  254.     Handle h;
  255.     
  256.     ClearMenuBar();
  257.     
  258.     for (i = APPLE_MENU; i <= RATE_MENU; i++) {
  259.     
  260.         if (i == APPLE_MENU) {
  261.             AddResMenu(GetMenu(i),'DRVR');    /* add in DA's */
  262.         }
  263.             
  264.         InsertMenu(GetMenu(i),0);
  265.     }
  266.     
  267.     DrawMenuBar();
  268. }
  269.  
  270.  
  271.  
  272. /*****
  273.  *  SIDSetup -- initializes SID and sets all of the window and sampling parameters
  274.  *
  275.  */
  276. SIDSetup()
  277. {
  278.     HHInit(1);
  279.     HHFrontWindow(FrontStartThresh,FrontLength,FrontMaxWait);
  280.     HHRearWindow(RearQuietThresh,RearLength);
  281.     HHSampleRate(SampleRate);
  282. }
  283.  
  284.  
  285.  
  286. /*****
  287.  *  HandleMenu -- handles all menu choices from the user
  288.  *
  289.  */
  290. HandleMenu(doneFlag,theMenu,theItem)
  291. Boolean *doneFlag;
  292. int theMenu,theItem;
  293. {
  294.     Boolean daEdit;            /* for SystemEdit result of DA edits */
  295.     Str255 deskAccName;        /* name of requested desk accessory */
  296.     ControlHandle ctrl;        /* used for setting control attributes */
  297.     GrafPtr savePort;        /* saved port to bracket DA call... */
  298.     PenState penSave;        /* saved pen parameters */
  299.     int i;
  300.     
  301.     switch (theMenu) {
  302.     
  303.         case APPLE_MENU:
  304.             if (theItem == ABOUT_ITEM)
  305.                 DoAboutBox();
  306.             else {
  307.                 GetPort(&savePort);
  308.                 GetItem(GetMenu(APPLE_MENU),theItem,deskAccName);
  309.                 OpenDeskAcc(deskAccName);
  310.                 SetPort(savePort);
  311.             }
  312.             break;
  313.         
  314.         case FILE_MENU:
  315.             *doneFlag = TRUE;        /* Quit is the only File choice */
  316.             break;
  317.             
  318.         case RECORD_MENU:
  319.             if (!SIDStatus) {        /* complain is SID isn't alive */
  320.                 ParamText("\pSID is not responding","","","");
  321.                 Alert(SID_ALERT,0L);
  322.                 break;
  323.             }
  324.             if (theItem == DISK_ITEM) {
  325.                 HandleDiskRecord();
  326.             }
  327.             else
  328.                 HandleRAMRecord();
  329.             break;
  330.         
  331.         case PLAY_MENU:
  332.             if (theItem == DISK_ITEM) {
  333.                 HandleDiskPlay();
  334.             }
  335.             else
  336.                 HandleRAMPlay();
  337.             break;
  338.             
  339.         case WINDOWS_MENU:
  340.             if (theItem == FRONT_ITEM) {
  341.                 HandleFrontDialog();
  342.             }
  343.             else if (theItem == REAR_ITEM) {
  344.                 HandleRearDialog();
  345.             }
  346.             else if (theItem == MOUSEFLAG_ITEM) {
  347.                 if (MouseFlag == TRUE) {
  348.                     MouseFlag = FALSE;
  349.                     CheckItem(GetMenu(WINDOWS_MENU),MOUSEFLAG_ITEM,FALSE);
  350.                 }
  351.                 else {
  352.                     MouseFlag = TRUE;
  353.                     CheckItem(GetMenu(WINDOWS_MENU),MOUSEFLAG_ITEM,TRUE);
  354.                 }
  355.             }
  356.             break;
  357.             
  358.         case RATE_MENU:
  359.             HHSampleRate(theItem);
  360.             SampleRate = theItem;
  361.             for (i = 1; i < 5; i++)
  362.                 CheckItem(GetMenu(RATE_MENU),i,FALSE);
  363.             CheckItem(GetMenu(RATE_MENU),SampleRate,TRUE);
  364.             break;
  365.     }
  366.     
  367.     HiliteMenu(0);
  368. }
  369.  
  370.  
  371.  
  372. /*****
  373.  *  HandleRAMRecord -- record from SID to a RAM buffer
  374.  *
  375.  */
  376. HandleRAMRecord()
  377. {
  378.     EnableItem(GetMenu(PLAY_MENU),RAM_ITEM);
  379.     RecordDialog(RAMREC_DIALOG,TRUE);            /* display the RECORDING dialog */
  380.     if (!HHRecord(Buffer,BufLen,0,MouseFlag,&RecordLen) && HHError() != INTERRUPT) {
  381.         ParamText("\pRecording Error","","","");
  382.         Alert(SID_ALERT,0L);        /* this is pretty poor error checking... */
  383.                                     /* ...check HHError() for an error code... */
  384.                                     /* ...and look up that error code in HearHere.h */
  385.     }
  386.     else if (RecordLen == -1L)        /* -1 means that the buffer was filled */
  387.         RecordLen = BufLen;            /* ...remember the real length recorded */
  388.         
  389.     RecordDialog(RAMREC_DIALOG,FALSE);        /* remove the RECORDING dialog */
  390. }
  391.  
  392.  
  393.  
  394. HandleDiskRecord()
  395. {
  396.     int refNum;
  397.     Boolean b;
  398.     Point sfPt;
  399.     SFReply reply;
  400.     OSErr err;
  401.     
  402.             /*****
  403.              *  Ask the user for a filename to record to
  404.              *
  405.              */
  406.     SetPt(&sfPt,80,90);
  407.     SFPutFile(sfPt,"","",0L,&reply);
  408.     if (!reply.good)
  409.         return;
  410.         
  411.     err = Create(reply.fName,reply.vRefNum,'SID ','DATA');
  412.     if (err == -48)                /* ignore "File Exists" error */
  413.         err = 0;
  414.  
  415.     DisableItem(GetMenu(PLAY_MENU),RAM_ITEM);    /* this will kill the RAM buffer */
  416.     
  417.     err |= FSOpen(reply.fName,reply.vRefNum,&refNum);
  418.     if (err != noErr) {
  419.         ParamText("\pError opening file...","","","");
  420.         Alert(SID_ALERT,0L);
  421.         return;
  422.     }
  423.     
  424.     SetEOF(refNum,0L);            /* compact the file... */
  425.     
  426.             /*****
  427.              *  Record to the open file
  428.              *
  429.              */
  430.     RecordDialog(DISKREC_DIALOG,TRUE);    /* display the RECORDING dialog */
  431.     if (!HHRecord(Buffer,BufLen,refNum,MouseFlag,&RecordLen) && HHError() != INTERRUPT) {
  432.         ParamText("\pRecording Error","","","");
  433.         Alert(SID_ALERT,0L);
  434.     }
  435.     RecordDialog(DISKREC_DIALOG,FALSE);        /* remove the RECORDING dialog */
  436.     
  437.     FSClose(refNum);            /* close the file */
  438. }
  439.  
  440.  
  441.  
  442. /*****
  443.  *  RecordDialog -- handle the RECORDING dialog box
  444.  *
  445.  */
  446. RecordDialog(whichOne,display)
  447. int whichOne;
  448. Boolean display;
  449. {
  450.     int item,x,y;
  451.     long startTicks,time;
  452.     static DialogPtr d;
  453.     static GrafPtr saveport;
  454.     PicHandle h;
  455.     Str255 t;
  456.     Rect r;
  457.     
  458.     if (display) {
  459.         GetPort(&saveport);
  460.         x = ((screenBits.bounds.left + screenBits.bounds.right) >> 1) - 125;
  461.         y = ((screenBits.bounds.top + screenBits.bounds.bottom) >> 1) - 92;
  462.         d = GetNewDialog(whichOne,0L,-1L);
  463.         h = GetPicture(RECORD_PICT);
  464.         SetRect(&r,36,57,215,127);
  465.         time = ((long) BUFFERSIZE * (long) SampleRate / 22254L) + 1L; /* just approx */
  466.         NumToString(time,t);
  467.         ParamText(t,"","","");
  468.         MoveWindow(d,x,y,FALSE);
  469.         if (d != 0L) {
  470.             SetPort(d);
  471.             ShowWindow(d);
  472.             DrawDialog(d);
  473.             startTicks = Ticks;
  474.             while (Ticks - startTicks < 180)
  475.                 ;
  476.             DrawPicture(h,&r);
  477.         }
  478.     }
  479.     else {
  480.         if (d != 0L)
  481.             DisposDialog(d);
  482.         FlushEvents(everyEvent,0);
  483.         SetPort(saveport);
  484.     }
  485. }
  486.  
  487.  
  488.  
  489. /*****
  490.  *  HandleRAMPlay -- play back the RAM recording
  491.  *    Note: this demonstrates how to use the standard Mac toolbox to play back
  492.  *        recordings done with HearHere.
  493.  *
  494.  */
  495. HandleRAMPlay()
  496. {
  497.     long len;
  498.     FFSynthPtr b;
  499.     OSErr err;
  500.  
  501.     StopSound();                        /* kill any existing sound before playing */
  502.     
  503.             /*****
  504.              *  This will build a FFSynthRec right into the sound buffer
  505.              *  which will kill the first few bytes of sound data.  A better
  506.              *  approach would be to copy the sound data into a new FFSynthRec
  507.              *  but that would require more RAM.
  508.              *
  509.              */
  510.     b = (FFSynthPtr) Buffer;
  511.     b->mode = ffMode;                    /* SID data is in ffMode format */
  512.     b->count = FixRatio(1,SampleRate);    /* this sets the sample rate for playback */
  513.     
  514.     SetSoundVol(7);                        /* set the sound level to the max... */
  515.     
  516.     StartSound(b,RecordLen-10,-1L);        /* the Mac ROM's do all the hard work! */
  517. }
  518.  
  519.  
  520.  
  521. /*****
  522.  *  HandleDiskPlay -- play back a disk recording
  523.  *
  524.  */
  525. HandleDiskPlay()
  526. {
  527.     int refNum;
  528.     Point sfPt;
  529.     long sfType;
  530.     SFReply reply;
  531.     OSErr err;
  532.     
  533.             /*****
  534.              *  Ask the user for a filename to play
  535.              *
  536.              */
  537.     SetPt(&sfPt,80,90);
  538.     sfType = (long) 'DATA';
  539.     SFGetFile(sfPt,"",0L,1,&sfType,0L,&reply);
  540.     if (!reply.good)
  541.         return;
  542.         
  543.     err = FSOpen(reply.fName,reply.vRefNum,&refNum);
  544.     if (err != noErr) {
  545.         ParamText("\pError opening file...","","","");
  546.         Alert(SID_ALERT,0L);
  547.         return;
  548.     }
  549.     
  550.     SetFPos(refNum,1,0L);
  551.     
  552.     DisableItem(GetMenu(PLAY_MENU),RAM_ITEM);    /* this will kill the RAM buffer */
  553.     
  554.             /*****
  555.              *  Use HearHere to playback the data from the opened file...
  556.              *
  557.              */
  558.     if (!HHDiskPlay(refNum,Buffer,BufLen)) {
  559.         ParamText("\pError playing sound...","","","");
  560.         Alert(SID_ALERT,0L);
  561.     }
  562.  
  563.     FSClose(refNum);        /* close the file */
  564. }
  565.  
  566.  
  567.  
  568. /*****
  569.  *  AboutFilter -- just waits around for a mouse or key press 
  570.  *
  571.  */
  572. pascal Boolean AboutFilter(d,event,item)
  573. DialogPtr d;
  574. EventRecord *event;
  575. int *item;
  576. {
  577.     if (event->what == mouseDown || event->what == keyDown) {
  578.         *item = 1;
  579.         return TRUE;
  580.     }
  581.                 
  582.     *item = 0;
  583.     return FALSE;
  584. }
  585.  
  586.  
  587.  
  588. /*****
  589.  *  DoAboutBox -- display the about box
  590.  *
  591.  */
  592. DoAboutBox()
  593. {
  594.     int item,x,y;
  595.     DialogPtr d;
  596.     GrafPtr saveport;
  597.  
  598.     GetPort(&saveport);
  599.     x = ((screenBits.bounds.left + screenBits.bounds.right) >> 1) - 142;
  600.     y = ((screenBits.bounds.top + screenBits.bounds.bottom) >> 1) - 85;
  601.     d = GetNewDialog(ABOUT_DIALOG,0L,-1L);
  602.     MoveWindow(d,x,y,FALSE);
  603.     if (d != 0L) {
  604.         SetPort(d);
  605.         ShowWindow(d);
  606.         do {
  607.             ModalDialog(AboutFilter,&item);
  608.         }
  609.         while (item == 0);
  610.         
  611.         DisposDialog(d);
  612.         FlushEvents(everyEvent,0);
  613.         SetPort(saveport);
  614.     }
  615. }
  616.  
  617.  
  618.  
  619. /*****
  620.  *  DoOpeningBox -- same as about box, but draws the opening dialog box
  621.  *
  622.  */
  623. DoOpeningBox()
  624. {
  625.     int item,x,y;
  626.     DialogPtr d;
  627.     GrafPtr saveport;
  628.  
  629.     GetPort(&saveport);
  630.     x = ((screenBits.bounds.left + screenBits.bounds.right) >> 1) - 184;
  631.     y = ((screenBits.bounds.top + screenBits.bounds.bottom) >> 1) - 143;
  632.     d = GetNewDialog(OPENING_DIALOG,0L,-1L);
  633.     MoveWindow(d,x,y,FALSE);
  634.     if (d != 0L) {
  635.         SetPort(d);
  636.         ShowWindow(d);
  637.         do {
  638.             ModalDialog(AboutFilter,&item);
  639.         }
  640.         while (item == 0);
  641.         
  642.         DisposDialog(d);
  643.         FlushEvents(everyEvent,0);
  644.         SetPort(saveport);
  645.     }
  646. }
  647.  
  648.  
  649.  
  650. /*****
  651.  *  HandleFrontDialog -- handles the filling out of the front window dialog
  652.  *
  653.  */
  654. HandleFrontDialog()
  655. {
  656.     int iType,item;
  657.     long num;
  658.     Handle stHdl,flHdl,mwHdl;
  659.     Str255 stStr,flStr,mwStr;
  660.     Rect iRect;
  661.     DialogPtr theDialog;
  662.     
  663.     theDialog = GetNewDialog(FRONT_DIALOG,0L,-1L);
  664.     GetDItem(theDialog,ST_ITEM,&iType,&stHdl,&iRect);
  665.     NumToString((long) FrontStartThresh,&stStr);
  666.     SetIText(stHdl,stStr);
  667.     SelIText(theDialog,ST_ITEM,0,32767);
  668.     GetDItem(theDialog,FL_ITEM,&iType,&flHdl,&iRect);
  669.     NumToString((long) FrontLength,&flStr);
  670.     SetIText(flHdl,flStr);
  671.     GetDItem(theDialog,MW_ITEM,&iType,&mwHdl,&iRect);
  672.     NumToString((long) FrontMaxWait,&mwStr);
  673.     SetIText(mwHdl,mwStr);
  674.  
  675.     item = 0;
  676.     while (item != OK && item != CANCEL)
  677.         ModalDialog(0L,&item);
  678.     
  679.     if (item == OK) {
  680.         GetIText(stHdl,&stStr);
  681.         GetIText(flHdl,&flStr);
  682.         GetIText(mwHdl,&mwStr);
  683.         StringToNum(stStr,&num);
  684.         FrontStartThresh = num;
  685.         StringToNum(flStr,&num);
  686.         FrontLength = num;
  687.         StringToNum(mwStr,&num);
  688.         FrontMaxWait = num;
  689.         HHFrontWindow(FrontStartThresh,FrontLength,FrontMaxWait);
  690.     }
  691.     
  692.     DisposDialog(theDialog);
  693. }
  694.  
  695.  
  696.  
  697. /*****
  698.  *  HandleRearDialog -- handles the filling out of the rear window dialog
  699.  *
  700.  */
  701. HandleRearDialog()
  702. {
  703.     int iType,item;
  704.     long num;
  705.     Handle qtHdl,rlHdl;
  706.     Str255 qtStr,rlStr;
  707.     Rect iRect;
  708.     DialogPtr theDialog;
  709.     
  710.     theDialog = GetNewDialog(REAR_DIALOG,0L,-1L);
  711.     GetDItem(theDialog,QT_ITEM,&iType,&qtHdl,&iRect);
  712.     NumToString((long) RearQuietThresh,&qtStr);
  713.     SetIText(qtHdl,qtStr);
  714.     SelIText(theDialog,QT_ITEM,0,32767);
  715.     GetDItem(theDialog,RL_ITEM,&iType,&rlHdl,&iRect);
  716.     NumToString((long) RearLength,&rlStr);
  717.     SetIText(rlHdl,rlStr);
  718.  
  719.     item = 0;
  720.     while (item != OK && item != CANCEL)
  721.         ModalDialog(0L,&item);
  722.     
  723.     if (item == OK) {
  724.         GetIText(qtHdl,&qtStr);
  725.         GetIText(rlHdl,&rlStr);
  726.         StringToNum(qtStr,&num);
  727.         RearQuietThresh = num;
  728.         StringToNum(rlStr,&num);
  729.         RearLength = num;
  730.         HHRearWindow(RearQuietThresh,RearLength);
  731.     }
  732.     
  733.     DisposDialog(theDialog);
  734. }
  735.  
  736.